Introduction
Get a Quick Summary
It’s always a good idea to glance at the data
Grouping and Summarizing Operations
A very common operation is to do things by group(s) then create new summary variables.
Grouping and Summarizing Operations
Do multiple operations at once
Mapping functions to groups
We’ll use the map function to map the sum function to each element in the list
Grouping and Summarizing Operations
We can even do this with modeling and other operations.
This extracts the coefficients from a model run for each group.
Visualization
Visualizing data requires that you: - Consider carefully the information you want to display - And then how you want to display it
Tell a story with the data.
And have some fun with it!
ggplot2
The most widely used visualization package in R
Layers
Visualization can be thought of in a layered fashion
Start with the base, then build up
More pipes
ggplot2 uses a + as a pipe to add layers
We can pipe to any ggplot as we did before (%>%)
Aesthetics
Aesthetics (aes) map variables to visual properties
Geoms are the geometric units we want to display
Stats
We can also use ggplot2 to create statistics we want to visualize
Typically used indirectly when geoms are called
Can be used for more direct control
Scales
Scales are used to add specifications to axes, colors, etc.
model_variables %>%
filter(award_total_amount >= 1e6) %>%
ggplot() +
geom_density(aes(x = award_total_amount,
color = gender,
fill = gender),
alpha = .2) +
scale_x_continuous(breaks = c(1e6, 5e6, 1e7, 2.5e7, 5e7),
trans = 'log') +
scale_fill_viridis_d(begin = .25, end = .5) +
scale_color_viridis_d(begin = .25, end = .5)
Facets
Facets allow another dimension to plots by group
- facet_grid: returns a matrix of like dimensions
- facet_wrap: more flexible specification
Themes
Themes allow for customization
Two uses of a - a built-in versions (e.g. theme_minimal) - DIY (theme(…))
For the theme function, each argument, takes on a specific value or an element function:
element_rect
element_line
element_text
element_blank
Interactivity
Interactivity is a must-have tool for web-based presentation
Use to enhance exploration of the data - Not just because one can
Allows for additional dimensions
Even useful for exploring raw data
Interactivity
General
- plotly
- also used in Python, Matlab, Julia
- can convert
ggplot2 images to interactive ones
- highcharter
- general wrapper for highcharts.js
- works with some R packages out of the box
- rbokeh
- like plotly, it also has cross language support
Interactivity
Specific functionality:
Plotly
traces - add_, work similar to geoms
modes - allow for points, lines, text and combinations
aesthetics - variables are denoted with ~, constants do not use - x =~ var1 vs x = 2
Plotly
Plotly uses the standard pipe %>%
Plotly
Use ggplotly to turn our formerly static plots into interactive ones.
Python examples
Grouping and Summarizing data
Visualization
matplotlib is the most common visualization module in Python, though it’s fairly dated at this point. As such we’ll use a ggplot implementation in python called plotnine.
Unfortunately for plotly, the interactivity makes it unusable within the R notebook (at present), so you may need to switch to Anaconda or other IDE to try other modules like plotly. Even Python users will still use R for easier visualization though, so feel free to do what you like there, then use ggplot etc. in R when the time comes.
That said, I’ll show a couple plots
---
title: "Module 2: Summarizing and Visualizing Data"
output: 
  html_notebook: 
    highlight: pygments
    theme: sandstone
    css: other.css
editor_options: 
  chunk_output_type: inline
---

```{r init, echo=FALSE}
# these options are primary useful to the creation of the html document
knitr::opts_chunk$set(
  echo=T, 
  eval = F,
  message = F, 
  warning = F, 
  comment = NA,
  R.options=list(width=120), 
  cache.rebuild=F, 
  cache=F,
  fig.align='center', 
  fig.asp = .7,
  dev = 'svg', 
  dev.args=list(bg = 'transparent')
)
```

```{r catchup, eval=TRUE}
library(tidyverse)
demographics = read.csv('data/demos_anonymized.csv')
ids = read.csv('data/ids_anonymized.csv')
model_variables = read.csv('data/model_variables_anonymized.csv')
```

## Introduction

## Get a Quick Summary

It's always a good idea to glance at the data

```{r summary}
glimpse(demographics)
```
```{r}
summary(demographics[,1:10])
```



## Grouping and Summarizing Operations

A very common operation is to do things by group(s) then create new summary variables.

```{r group_by, eval=TRUE}
demographics %>% 
  group_by(libuser) %>% 
  summarise(age = mean(age, na.rm = T)) 
```



## Grouping and Summarizing Operations

Do multiple operations at once

```{r group_by2, eval=TRUE}
demographics %>% 
  group_by(libuser) %>% 
  summarise(age_mean = mean(age, na.rm = T),
            age_sd = sd(age, na.rm = T),
            age_max = max(age, na.rm = T),
            prop_male = mean(gender=='Male', na.rm = T)) 
```



##  Mapping functions to groups

We’ll use the `map` function to *map* the `sum` function to each element in the list

```{r map, eval=TRUE}
x = list(1:3, 4:6, 7:9)
map(x, sum)
```



## Grouping and Summarizing Operations

We can even do this with modeling and other operations. 

This extracts the coefficients from a model run for each group.

```{r group_by3, eval=TRUE}
demographics %>% 
  drop_na(race) %>% 
  group_split(race) %>%   
  map(~lm(award_total_amount ~ gender, data = .))
```


## Visualization

Visualizing data requires that you:
- Consider carefully the information you want to display
- And then how you want to display it

Tell a story with the data.

And have some fun with it!


## ggplot2

The most widely used visualization package in R



## Layers

Visualization can be thought of in a layered fashion

Start with the base, then build up

## More pipes

`ggplot2` uses a `+` as a pipe to add layers

```{r ggplot2, eval=FALSE}
library(ggplot2)
ggplot(data) +
  geom_point(aes(x = var1, y = var2)) +
  geom_line() +
  theme(plot.caption = element_text(size = 6))
```

We can pipe *to* any ggplot as we did before (` %>% `)



## Aesthetics

**Aesthetics** (`aes`) map variables to visual properties

**Geoms** are the geometric units we want to display


## Aesthetics

```{r aesthetics}
model_variables %>% 
  filter(award_total_amount > 1e7) %>% 
  ggplot() +
  geom_density(aes(x = award_total_amount, 
                   color = factor(gender),
                   fill = factor(gender)),
               alpha = .2) + 
  scale_x_continuous(breaks = (1:10) * 1e7, trans = 'log')
```

```{r aesthetics2}
demographics %>% 
  filter(award_year_start < 2020 & award_year_start > 1990) %>%  
  ggplot(aes(award_year_start, award_total_log)) + 
  geom_smooth(aes(color=factor(libuser)))
```


## Stats

We can also use ggplot2 to create statistics we want to visualize

Typically used indirectly when geoms are called

Can be used for more direct control

```{r ggstats2}
ggplot(model_variables, aes(age, award_total_amount)) +
  geom_point(alpha = .02) +
  stat_ellipse(color = '#ff5500')
```



## Scales

Scales are used to add specifications to axes, colors, etc.

```{r scales}
model_variables %>% 
  filter(award_total_amount >= 1e6) %>% 
  ggplot() +
  geom_density(aes(x = award_total_amount, 
                   color = gender,
                   fill = gender),
               alpha = .2) + 
  scale_x_continuous(breaks = c(1e6, 5e6, 1e7, 2.5e7, 5e7), 
                     trans = 'log') +
  scale_fill_viridis_d(begin = .25, end = .5) +
  scale_color_viridis_d(begin = .25, end = .5) 
```


## Facets

Facets allow another dimension to plots by group

- **facet_grid**: returns a matrix of like dimensions
- **facet_wrap**: more flexible specification

```{r facets}
model_variables %>% 
  ggplot() +
  geom_density(aes(x = award_total_amount, 
                   color = libuser,
                   fill = libuser),
               alpha = .2) +
  facet_wrap(~gender)
```




## Themes

`Themes` allow for customization

Two uses of a 
- a built-in versions (e.g. `theme_minimal`)
- DIY  (`theme`(...))

For the theme function, each argument, takes on a specific value or an element function:

- `element_rect`
- `element_line`
- `element_text`
- `element_blank`


## Themes

```{r themes1}
model_variables %>% 
  ggplot() +
  geom_smooth(aes(x = age,
                y = award_total_amount,
                color = libuser),
               alpha = .2) + 
  theme_minimal()
```


```{r themes2}
model_variables %>% 
  ggplot() +
  geom_smooth(aes(x = age,
                y = award_total_amount,
                color = libuser),
               alpha = .2) + 
  theme(axis.text.x = element_text(size=12),
        panel.grid.minor.x = element_blank(),
        plot.background = element_rect(color = 'rosybrown'),
        panel.background = element_rect(fill = 'papayawhip'))
```

## Interactivity

Interactivity is a must-have tool for web-based presentation

Use to enhance exploration of the data
- Not just because one can

Allows for additional dimensions

Even useful for exploring raw data



## Interactivity


General 

- [plotly](https://plot.ly/r/)
  - also used in Python, Matlab, Julia
  - can convert `ggplot2` images to interactive ones
  
- [highcharter](http://jkunst.com/highcharter/)
  - general wrapper for highcharts.js 
  - works with some R packages out of the box
  
- [rbokeh](http://hafen.github.io/rbokeh/)
  - like plotly, it also has cross language support



## Interactivity

Specific functionality:

- [DT](https://rstudio.github.io/DT/)
  - interactive data tables
  
- [leaflet](https://rstudio.github.io/leaflet/)
    - maps with OpenStreetMap
    
- [visNetwork](http://datastorm-open.github.io/visNetwork/)
    - Network visualization
    


## Plotly

`traces`
- `add_`, work similar to geoms
  
`modes`
- allow for points, lines, text and combinations

`aesthetics`
- variables are denoted with `~`, constants do not use
- `x =~ var1` vs `x = 2`




## Plotly

Plotly uses the standard pipe `%>%`

```{r plotly}
library(plotly)

model_variables %>% 
  plot_ly(x = ~gender, y = ~ age) %>% 
  add_boxplot(color =~ gender)
```



## Plotly

```{r plotly1}
library(plotly)

model_variables %>% 
  group_by(libuser, gender) %>% 
  summarise(award = mean(award_total_amount)) %>% 
  plot_ly(x = ~libuser, 
          y = ~award, 
          color = ~gender,
          text = ~round(award), 
          textposition = 'auto', 
          type = 'bar') %>% 
  layout(bargap = 0.25, 
         bargroupgap = 0.25)
```



## Plotly

```{r plotly2}
init = glm(award_total_amount >= 5000000 ~ age*libuser, 
           data = model_variables, 
           family = binomial)

model_variables %>% 
  modelr::add_predictions(init, type = 'response') %>% 
  plot_ly(x = ~age, y = ~ pred) %>% 
  add_lines(color =~ libuser, line = list(shape = "spline")) %>% 
  layout(title = 'Predicted Prob. Award > 1 mil')
```



## Plotly

Use ggplotly to turn our formerly static plots into interactive ones. 

```{r plotly3}
p = model_variables %>% 
  ggplot() +
  geom_density(aes(x = log(award_total_amount), 
                   color = libuser,
                   fill = libuser),
               alpha = .2) + 
  facet_wrap(~ gender) 
ggplotly()
```




## Python examples

### Init

```{python py_init, engine.path= '/Users/micl/anaconda3/bin/python'}
import pandas as pd
import numpy as np

demographics = pd.read_csv('data/demos_anonymized.csv')
ids = pd.read_csv('data/ids_anonymized.csv')
model_variables = pd.read_csv('data/model_variables_anonymized.csv')
```


###  Grouping and Summarizing data

```{python py_summary}
demographics.describe(include = 'all')
```
```{python py_summary_numeric}
demographics.describe(include = [np.number])
```

```{python py_summary_string}
demographics.describe(include = [np.object])
```




```{python py_group_by, eval=TRUE}
lib_group = demographics.groupby('libuser', sort=True, )

# automatically chooses numeric
lib_group.mean()
```


```{python py_group_by2, eval=TRUE}
lib_group.get_group(0).head()
```


```{python py_group_by3, eval=TRUE}
lib_group.size()
```

```{python py_group_by4, eval=TRUE}
lib_group.describe()
```
### Mapping a function

```{python py_map}
x = [[1,2,3], [4,5,6], [7,8,9]]
list(map(np.sum, x))
```

```{python py_map2}
demographics.select_dtypes('number').apply(np.mean)
```


### Visualization

`matplotlib` is the most common visualization module in Python, though it's fairly dated at this point. As such we'll use a ggplot implementation in python called `plotnine`.

Unfortunately for plotly, the interactivity makes it unusable within the R notebook (at present), so you may need to switch to Anaconda or other IDE to try other modules like `plotly`.  Even Python users will still use R for easier visualization though, so feel free to do what you like there, then use ggplot etc. in R when the time comes.

That said, I'll show a couple plots

```{python plotnine}
import plotnine
```

```{python gg1}
dplot = demographics[(demographics.award_year_start < 2020) & (demographics.award_year_start > 1990) & (demographics.award_total_log > 11)]
dplot
ggplot(dplot, aes(x='award_year_start', y='award_total_log')) + geom_smooth(aes(group = 'libuser', color = 'libuser'))
```


```{python gg2}
year_award_average = demographics[demographics.libuser == 1].groupby(['award_home_dept', 'award_year_start']).mean()
year_award_average
```



```{python py_plotly_init}
import plotly
import plotly.plotly as py
from plotly.offline import init_notebook_mode
import plotly.graph_objs as go
plotly.offline.init_notebook_mode(connected=True)
```


```{python py_plotly}
y0 = np.random.randn(50)-1
y1 = np.random.randn(50)+1

trace0 = go.Box(
    y=y0
)
trace1 = go.Box(
    y=y1
)
data = [trace0, trace1]
py.iplot(data)
```


```{python}
```
